/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Persistencia.JPAControllers;

import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import Logica.Core.Depositos.Deposito;
import Logica.Core.Depositos.LoteCanchada;
import Logica.Core.Producto.Producto;
import Persistencia.JPAControllers.exceptions.NonexistentEntityException;
import Persistencia.JPAControllers.exceptions.PreexistingEntityException;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 *
 * @author DANIEL
 */
public class LoteCanchadaJpaController implements Serializable {

    public LoteCanchadaJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public LoteCanchadaJpaController() {
        emf = Persistence.createEntityManagerFactory("SecaderoPU");
    }

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(LoteCanchada loteCanchada) throws PreexistingEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Deposito miDeposito = loteCanchada.getMiDeposito();
            if (miDeposito != null) {
                miDeposito = em.getReference(miDeposito.getClass(), miDeposito.getId());
                loteCanchada.setMiDeposito(miDeposito);
            }
            Producto miProducto = loteCanchada.getMiProducto();
            if (miProducto != null) {
                miProducto = em.getReference(miProducto.getClass(), miProducto.getId());
                loteCanchada.setMiProducto(miProducto);
            }
            em.persist(loteCanchada);
            if (miDeposito != null) {
                miDeposito.getMisLotes().add(loteCanchada);
                miDeposito = em.merge(miDeposito);
            }
            if (miProducto != null) {
                Logica.Core.Depositos.Lote oldMiLoteOfMiProducto = miProducto.getMiLote();
                if (oldMiLoteOfMiProducto != null) {
                    oldMiLoteOfMiProducto.setMiProducto(null);
                    oldMiLoteOfMiProducto = em.merge(oldMiLoteOfMiProducto);
                }
                miProducto.setMiLote(loteCanchada);
                miProducto = em.merge(miProducto);
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findLoteCanchada(loteCanchada.getNumero()) != null) {
                throw new PreexistingEntityException("LoteCanchada " + loteCanchada + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(LoteCanchada loteCanchada) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            LoteCanchada persistentLoteCanchada = em.find(LoteCanchada.class, loteCanchada.getNumero());
            Deposito miDepositoOld = persistentLoteCanchada.getMiDeposito();
            Deposito miDepositoNew = loteCanchada.getMiDeposito();
            Producto miProductoOld = persistentLoteCanchada.getMiProducto();
            Producto miProductoNew = loteCanchada.getMiProducto();
            if (miDepositoNew != null) {
                miDepositoNew = em.getReference(miDepositoNew.getClass(), miDepositoNew.getId());
                loteCanchada.setMiDeposito(miDepositoNew);
            }
            if (miProductoNew != null) {
                miProductoNew = em.getReference(miProductoNew.getClass(), miProductoNew.getId());
                loteCanchada.setMiProducto(miProductoNew);
            }
            loteCanchada = em.merge(loteCanchada);
            if (miDepositoOld != null && !miDepositoOld.equals(miDepositoNew)) {
                miDepositoOld.getMisLotes().remove(loteCanchada);
                miDepositoOld = em.merge(miDepositoOld);
            }
            if (miDepositoNew != null && !miDepositoNew.equals(miDepositoOld)) {
                miDepositoNew.getMisLotes().add(loteCanchada);
                miDepositoNew = em.merge(miDepositoNew);
            }
            if (miProductoOld != null && !miProductoOld.equals(miProductoNew)) {
                miProductoOld.setMiLote(null);
                miProductoOld = em.merge(miProductoOld);
            }
            if (miProductoNew != null && !miProductoNew.equals(miProductoOld)) {
                Logica.Core.Depositos.Lote oldMiLoteOfMiProducto = miProductoNew.getMiLote();
                if (oldMiLoteOfMiProducto != null) {
                    oldMiLoteOfMiProducto.setMiProducto(null);
                    oldMiLoteOfMiProducto = em.merge(oldMiLoteOfMiProducto);
                }
                miProductoNew.setMiLote(loteCanchada);
                miProductoNew = em.merge(miProductoNew);
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                int id = loteCanchada.getNumero();
                if (findLoteCanchada(id) == null) {
                    throw new NonexistentEntityException("The loteCanchada with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(int id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            LoteCanchada loteCanchada;
            try {
                loteCanchada = em.getReference(LoteCanchada.class, id);
                loteCanchada.getNumero();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The loteCanchada with id " + id + " no longer exists.", enfe);
            }
            Deposito miDeposito = loteCanchada.getMiDeposito();
            if (miDeposito != null) {
                miDeposito.getMisLotes().remove(loteCanchada);
                miDeposito = em.merge(miDeposito);
            }
            Producto miProducto = loteCanchada.getMiProducto();
            if (miProducto != null) {
                miProducto.setMiLote(null);
                miProducto = em.merge(miProducto);
            }
            em.remove(loteCanchada);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<LoteCanchada> findLoteCanchadaEntities() {
        return findLoteCanchadaEntities(true, -1, -1);
    }

    public List<LoteCanchada> findLoteCanchadaEntities(int maxResults, int firstResult) {
        return findLoteCanchadaEntities(false, maxResults, firstResult);
    }

    private List<LoteCanchada> findLoteCanchadaEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from LoteCanchada as o");
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public LoteCanchada findLoteCanchada(int id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(LoteCanchada.class, id);
        } finally {
            em.close();
        }
    }

    public int getLoteCanchadaCount() {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select count(o) from LoteCanchada as o");
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
}
